// coverage:ignore-file
// GENERATED CODE - DO NOT MODIFY BY HAND
// dart format off
// ignore_for_file: type=lint
// ignore_for_file: unused_element, unnecessary_cast, override_on_non_overriding_member
// ignore_for_file: strict_raw_type, inference_failure_on_untyped_parameter

part of 'tutorial.dart';

class TutorialDataMapper extends SubClassMapperBase<TutorialData> {
  TutorialDataMapper._();

  static TutorialDataMapper? _instance;
  static TutorialDataMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = TutorialDataMapper._());
      ProjectDataBaseMapper.ensureInitialized().addSubMapper(_instance!);
      TutorialStepConfigMapper.ensureInitialized();
      TutorialStepMapper.ensureInitialized();
    }
    return _instance!;
  }

  @override
  final String id = 'TutorialData';

  static String _$id(TutorialData v) => v.id;
  static const Field<TutorialData, String> _f$id = Field('id', _$id);
  static String _$description(TutorialData v) => v.description;
  static const Field<TutorialData, String> _f$description = Field(
    'description',
    _$description,
  );
  static int _$currentStep(TutorialData v) => v.currentStep;
  static const Field<TutorialData, int> _f$currentStep = Field(
    'currentStep',
    _$currentStep,
  );
  static List<TutorialStepConfig> _$configs(TutorialData v) => v.configs;
  static const Field<TutorialData, List<TutorialStepConfig>> _f$configs = Field(
    'configs',
    _$configs,
  );
  static Map<String, TutorialStep> _$steps(TutorialData v) => v.steps;
  static const Field<TutorialData, Map<String, TutorialStep>> _f$steps = Field(
    'steps',
    _$steps,
  );

  @override
  final MappableFields<TutorialData> fields = const {
    #id: _f$id,
    #description: _f$description,
    #currentStep: _f$currentStep,
    #configs: _f$configs,
    #steps: _f$steps,
  };

  @override
  final String discriminatorKey = 'type';
  @override
  final dynamic discriminatorValue = 'TutorialData';
  @override
  late final ClassMapperBase superMapper =
      ProjectDataBaseMapper.ensureInitialized();

  static TutorialData _instantiate(DecodingData data) {
    return TutorialData(
      data.dec(_f$id),
      data.dec(_f$description),
      data.dec(_f$currentStep),
      data.dec(_f$configs),
      data.dec(_f$steps),
    );
  }

  @override
  final Function instantiate = _instantiate;

  static TutorialData fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<TutorialData>(map);
  }

  static TutorialData fromJson(String json) {
    return ensureInitialized().decodeJson<TutorialData>(json);
  }
}

mixin TutorialDataMappable {
  String toJson() {
    return TutorialDataMapper.ensureInitialized().encodeJson<TutorialData>(
      this as TutorialData,
    );
  }

  Map<String, dynamic> toMap() {
    return TutorialDataMapper.ensureInitialized().encodeMap<TutorialData>(
      this as TutorialData,
    );
  }

  TutorialDataCopyWith<TutorialData, TutorialData, TutorialData> get copyWith =>
      _TutorialDataCopyWithImpl<TutorialData, TutorialData>(
        this as TutorialData,
        $identity,
        $identity,
      );
  @override
  String toString() {
    return TutorialDataMapper.ensureInitialized().stringifyValue(
      this as TutorialData,
    );
  }

  @override
  bool operator ==(Object other) {
    return TutorialDataMapper.ensureInitialized().equalsValue(
      this as TutorialData,
      other,
    );
  }

  @override
  int get hashCode {
    return TutorialDataMapper.ensureInitialized().hashValue(
      this as TutorialData,
    );
  }
}

extension TutorialDataValueCopy<$R, $Out>
    on ObjectCopyWith<$R, TutorialData, $Out> {
  TutorialDataCopyWith<$R, TutorialData, $Out> get $asTutorialData =>
      $base.as((v, t, t2) => _TutorialDataCopyWithImpl<$R, $Out>(v, t, t2));
}

abstract class TutorialDataCopyWith<$R, $In extends TutorialData, $Out>
    implements ClassCopyWith<$R, $In, $Out> {
  ListCopyWith<
    $R,
    TutorialStepConfig,
    TutorialStepConfigCopyWith<$R, TutorialStepConfig, TutorialStepConfig>
  >
  get configs;
  MapCopyWith<
    $R,
    String,
    TutorialStep,
    TutorialStepCopyWith<$R, TutorialStep, TutorialStep>
  >
  get steps;
  $R call({
    String? id,
    String? description,
    int? currentStep,
    List<TutorialStepConfig>? configs,
    Map<String, TutorialStep>? steps,
  });
  TutorialDataCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
}

class _TutorialDataCopyWithImpl<$R, $Out>
    extends ClassCopyWithBase<$R, TutorialData, $Out>
    implements TutorialDataCopyWith<$R, TutorialData, $Out> {
  _TutorialDataCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<TutorialData> $mapper =
      TutorialDataMapper.ensureInitialized();
  @override
  ListCopyWith<
    $R,
    TutorialStepConfig,
    TutorialStepConfigCopyWith<$R, TutorialStepConfig, TutorialStepConfig>
  >
  get configs => ListCopyWith(
    $value.configs,
    (v, t) => v.copyWith.$chain(t),
    (v) => call(configs: v),
  );
  @override
  MapCopyWith<
    $R,
    String,
    TutorialStep,
    TutorialStepCopyWith<$R, TutorialStep, TutorialStep>
  >
  get steps => MapCopyWith(
    $value.steps,
    (v, t) => v.copyWith.$chain(t),
    (v) => call(steps: v),
  );
  @override
  $R call({
    String? id,
    String? description,
    int? currentStep,
    List<TutorialStepConfig>? configs,
    Map<String, TutorialStep>? steps,
  }) => $apply(
    FieldCopyWithData({
      if (id != null) #id: id,
      if (description != null) #description: description,
      if (currentStep != null) #currentStep: currentStep,
      if (configs != null) #configs: configs,
      if (steps != null) #steps: steps,
    }),
  );
  @override
  TutorialData $make(CopyWithData data) => TutorialData(
    data.get(#id, or: $value.id),
    data.get(#description, or: $value.description),
    data.get(#currentStep, or: $value.currentStep),
    data.get(#configs, or: $value.configs),
    data.get(#steps, or: $value.steps),
  );

  @override
  TutorialDataCopyWith<$R2, TutorialData, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  ) => _TutorialDataCopyWithImpl<$R2, $Out2>($value, $cast, t);
}

class TutorialStepConfigMapper extends ClassMapperBase<TutorialStepConfig> {
  TutorialStepConfigMapper._();

  static TutorialStepConfigMapper? _instance;
  static TutorialStepConfigMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = TutorialStepConfigMapper._());
    }
    return _instance!;
  }

  @override
  final String id = 'TutorialStepConfig';

  static String _$id(TutorialStepConfig v) => v.id;
  static const Field<TutorialStepConfig, String> _f$id = Field('id', _$id);
  static String _$name(TutorialStepConfig v) => v.name;
  static const Field<TutorialStepConfig, String> _f$name = Field(
    'name',
    _$name,
  );

  @override
  final MappableFields<TutorialStepConfig> fields = const {
    #id: _f$id,
    #name: _f$name,
  };

  static TutorialStepConfig _instantiate(DecodingData data) {
    return TutorialStepConfig(data.dec(_f$id), data.dec(_f$name));
  }

  @override
  final Function instantiate = _instantiate;

  static TutorialStepConfig fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<TutorialStepConfig>(map);
  }

  static TutorialStepConfig fromJson(String json) {
    return ensureInitialized().decodeJson<TutorialStepConfig>(json);
  }
}

mixin TutorialStepConfigMappable {
  String toJson() {
    return TutorialStepConfigMapper.ensureInitialized()
        .encodeJson<TutorialStepConfig>(this as TutorialStepConfig);
  }

  Map<String, dynamic> toMap() {
    return TutorialStepConfigMapper.ensureInitialized()
        .encodeMap<TutorialStepConfig>(this as TutorialStepConfig);
  }

  TutorialStepConfigCopyWith<
    TutorialStepConfig,
    TutorialStepConfig,
    TutorialStepConfig
  >
  get copyWith =>
      _TutorialStepConfigCopyWithImpl<TutorialStepConfig, TutorialStepConfig>(
        this as TutorialStepConfig,
        $identity,
        $identity,
      );
  @override
  String toString() {
    return TutorialStepConfigMapper.ensureInitialized().stringifyValue(
      this as TutorialStepConfig,
    );
  }

  @override
  bool operator ==(Object other) {
    return TutorialStepConfigMapper.ensureInitialized().equalsValue(
      this as TutorialStepConfig,
      other,
    );
  }

  @override
  int get hashCode {
    return TutorialStepConfigMapper.ensureInitialized().hashValue(
      this as TutorialStepConfig,
    );
  }
}

extension TutorialStepConfigValueCopy<$R, $Out>
    on ObjectCopyWith<$R, TutorialStepConfig, $Out> {
  TutorialStepConfigCopyWith<$R, TutorialStepConfig, $Out>
  get $asTutorialStepConfig => $base.as(
    (v, t, t2) => _TutorialStepConfigCopyWithImpl<$R, $Out>(v, t, t2),
  );
}

abstract class TutorialStepConfigCopyWith<
  $R,
  $In extends TutorialStepConfig,
  $Out
>
    implements ClassCopyWith<$R, $In, $Out> {
  $R call({String? id, String? name});
  TutorialStepConfigCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  );
}

class _TutorialStepConfigCopyWithImpl<$R, $Out>
    extends ClassCopyWithBase<$R, TutorialStepConfig, $Out>
    implements TutorialStepConfigCopyWith<$R, TutorialStepConfig, $Out> {
  _TutorialStepConfigCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<TutorialStepConfig> $mapper =
      TutorialStepConfigMapper.ensureInitialized();
  @override
  $R call({String? id, String? name}) => $apply(
    FieldCopyWithData({if (id != null) #id: id, if (name != null) #name: name}),
  );
  @override
  TutorialStepConfig $make(CopyWithData data) => TutorialStepConfig(
    data.get(#id, or: $value.id),
    data.get(#name, or: $value.name),
  );

  @override
  TutorialStepConfigCopyWith<$R2, TutorialStepConfig, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  ) => _TutorialStepConfigCopyWithImpl<$R2, $Out2>($value, $cast, t);
}

class TutorialStepMapper extends SubClassMapperBase<TutorialStep> {
  TutorialStepMapper._();

  static TutorialStepMapper? _instance;
  static TutorialStepMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = TutorialStepMapper._());
      ProjectDataBaseMapper.ensureInitialized().addSubMapper(_instance!);
      ProjectDataMapper.ensureInitialized();
    }
    return _instance!;
  }

  @override
  final String id = 'TutorialStep';

  static String _$id(TutorialStep v) => v.id;
  static const Field<TutorialStep, String> _f$id = Field('id', _$id);
  static String _$name(TutorialStep v) => v.name;
  static const Field<TutorialStep, String> _f$name = Field('name', _$name);
  static String _$text(TutorialStep v) => v.text;
  static const Field<TutorialStep, String> _f$text = Field('text', _$text);
  static ProjectData _$step(TutorialStep v) => v.step;
  static const Field<TutorialStep, ProjectData> _f$step = Field('step', _$step);
  static ProjectData? _$solution(TutorialStep v) => v.solution;
  static const Field<TutorialStep, ProjectData> _f$solution = Field(
    'solution',
    _$solution,
  );
  static bool _$showSolution(TutorialStep v) => v.showSolution;
  static const Field<TutorialStep, bool> _f$showSolution = Field(
    'showSolution',
    _$showSolution,
    opt: true,
    def: false,
  );

  @override
  final MappableFields<TutorialStep> fields = const {
    #id: _f$id,
    #name: _f$name,
    #text: _f$text,
    #step: _f$step,
    #solution: _f$solution,
    #showSolution: _f$showSolution,
  };

  @override
  final String discriminatorKey = 'type';
  @override
  final dynamic discriminatorValue = 'TutorialStep';
  @override
  late final ClassMapperBase superMapper =
      ProjectDataBaseMapper.ensureInitialized();

  static TutorialStep _instantiate(DecodingData data) {
    return TutorialStep(
      data.dec(_f$id),
      data.dec(_f$name),
      data.dec(_f$text),
      data.dec(_f$step),
      data.dec(_f$solution),
      data.dec(_f$showSolution),
    );
  }

  @override
  final Function instantiate = _instantiate;

  static TutorialStep fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<TutorialStep>(map);
  }

  static TutorialStep fromJson(String json) {
    return ensureInitialized().decodeJson<TutorialStep>(json);
  }
}

mixin TutorialStepMappable {
  String toJson() {
    return TutorialStepMapper.ensureInitialized().encodeJson<TutorialStep>(
      this as TutorialStep,
    );
  }

  Map<String, dynamic> toMap() {
    return TutorialStepMapper.ensureInitialized().encodeMap<TutorialStep>(
      this as TutorialStep,
    );
  }

  TutorialStepCopyWith<TutorialStep, TutorialStep, TutorialStep> get copyWith =>
      _TutorialStepCopyWithImpl<TutorialStep, TutorialStep>(
        this as TutorialStep,
        $identity,
        $identity,
      );
  @override
  String toString() {
    return TutorialStepMapper.ensureInitialized().stringifyValue(
      this as TutorialStep,
    );
  }

  @override
  bool operator ==(Object other) {
    return TutorialStepMapper.ensureInitialized().equalsValue(
      this as TutorialStep,
      other,
    );
  }

  @override
  int get hashCode {
    return TutorialStepMapper.ensureInitialized().hashValue(
      this as TutorialStep,
    );
  }
}

extension TutorialStepValueCopy<$R, $Out>
    on ObjectCopyWith<$R, TutorialStep, $Out> {
  TutorialStepCopyWith<$R, TutorialStep, $Out> get $asTutorialStep =>
      $base.as((v, t, t2) => _TutorialStepCopyWithImpl<$R, $Out>(v, t, t2));
}

abstract class TutorialStepCopyWith<$R, $In extends TutorialStep, $Out>
    implements ClassCopyWith<$R, $In, $Out> {
  ProjectDataCopyWith<$R, ProjectData, ProjectData> get step;
  ProjectDataCopyWith<$R, ProjectData, ProjectData>? get solution;
  $R call({
    String? id,
    String? name,
    String? text,
    ProjectData? step,
    ProjectData? solution,
    bool? showSolution,
  });
  TutorialStepCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(Then<$Out2, $R2> t);
}

class _TutorialStepCopyWithImpl<$R, $Out>
    extends ClassCopyWithBase<$R, TutorialStep, $Out>
    implements TutorialStepCopyWith<$R, TutorialStep, $Out> {
  _TutorialStepCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<TutorialStep> $mapper =
      TutorialStepMapper.ensureInitialized();
  @override
  ProjectDataCopyWith<$R, ProjectData, ProjectData> get step =>
      $value.step.copyWith.$chain((v) => call(step: v));
  @override
  ProjectDataCopyWith<$R, ProjectData, ProjectData>? get solution =>
      $value.solution?.copyWith.$chain((v) => call(solution: v));
  @override
  $R call({
    String? id,
    String? name,
    String? text,
    ProjectData? step,
    Object? solution = $none,
    bool? showSolution,
  }) => $apply(
    FieldCopyWithData({
      if (id != null) #id: id,
      if (name != null) #name: name,
      if (text != null) #text: text,
      if (step != null) #step: step,
      if (solution != $none) #solution: solution,
      if (showSolution != null) #showSolution: showSolution,
    }),
  );
  @override
  TutorialStep $make(CopyWithData data) => TutorialStep(
    data.get(#id, or: $value.id),
    data.get(#name, or: $value.name),
    data.get(#text, or: $value.text),
    data.get(#step, or: $value.step),
    data.get(#solution, or: $value.solution),
    data.get(#showSolution, or: $value.showSolution),
  );

  @override
  TutorialStepCopyWith<$R2, TutorialStep, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  ) => _TutorialStepCopyWithImpl<$R2, $Out2>($value, $cast, t);
}

class TutorialResponseMapper extends ClassMapperBase<TutorialResponse> {
  TutorialResponseMapper._();

  static TutorialResponseMapper? _instance;
  static TutorialResponseMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = TutorialResponseMapper._());
      TutorialConfigMapper.ensureInitialized();
    }
    return _instance!;
  }

  @override
  final String id = 'TutorialResponse';

  static TutorialConfig? _$tutorial(TutorialResponse v) => v.tutorial;
  static const Field<TutorialResponse, TutorialConfig> _f$tutorial = Field(
    'tutorial',
    _$tutorial,
  );
  static String? _$error(TutorialResponse v) => v.error;
  static const Field<TutorialResponse, String> _f$error = Field(
    'error',
    _$error,
  );

  @override
  final MappableFields<TutorialResponse> fields = const {
    #tutorial: _f$tutorial,
    #error: _f$error,
  };

  static TutorialResponse _instantiate(DecodingData data) {
    return TutorialResponse(data.dec(_f$tutorial), data.dec(_f$error));
  }

  @override
  final Function instantiate = _instantiate;

  static TutorialResponse fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<TutorialResponse>(map);
  }

  static TutorialResponse fromJson(String json) {
    return ensureInitialized().decodeJson<TutorialResponse>(json);
  }
}

mixin TutorialResponseMappable {
  String toJson() {
    return TutorialResponseMapper.ensureInitialized()
        .encodeJson<TutorialResponse>(this as TutorialResponse);
  }

  Map<String, dynamic> toMap() {
    return TutorialResponseMapper.ensureInitialized()
        .encodeMap<TutorialResponse>(this as TutorialResponse);
  }

  TutorialResponseCopyWith<TutorialResponse, TutorialResponse, TutorialResponse>
  get copyWith =>
      _TutorialResponseCopyWithImpl<TutorialResponse, TutorialResponse>(
        this as TutorialResponse,
        $identity,
        $identity,
      );
  @override
  String toString() {
    return TutorialResponseMapper.ensureInitialized().stringifyValue(
      this as TutorialResponse,
    );
  }

  @override
  bool operator ==(Object other) {
    return TutorialResponseMapper.ensureInitialized().equalsValue(
      this as TutorialResponse,
      other,
    );
  }

  @override
  int get hashCode {
    return TutorialResponseMapper.ensureInitialized().hashValue(
      this as TutorialResponse,
    );
  }
}

extension TutorialResponseValueCopy<$R, $Out>
    on ObjectCopyWith<$R, TutorialResponse, $Out> {
  TutorialResponseCopyWith<$R, TutorialResponse, $Out>
  get $asTutorialResponse =>
      $base.as((v, t, t2) => _TutorialResponseCopyWithImpl<$R, $Out>(v, t, t2));
}

abstract class TutorialResponseCopyWith<$R, $In extends TutorialResponse, $Out>
    implements ClassCopyWith<$R, $In, $Out> {
  TutorialConfigCopyWith<$R, TutorialConfig, TutorialConfig>? get tutorial;
  $R call({TutorialConfig? tutorial, String? error});
  TutorialResponseCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  );
}

class _TutorialResponseCopyWithImpl<$R, $Out>
    extends ClassCopyWithBase<$R, TutorialResponse, $Out>
    implements TutorialResponseCopyWith<$R, TutorialResponse, $Out> {
  _TutorialResponseCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<TutorialResponse> $mapper =
      TutorialResponseMapper.ensureInitialized();
  @override
  TutorialConfigCopyWith<$R, TutorialConfig, TutorialConfig>? get tutorial =>
      $value.tutorial?.copyWith.$chain((v) => call(tutorial: v));
  @override
  $R call({Object? tutorial = $none, Object? error = $none}) => $apply(
    FieldCopyWithData({
      if (tutorial != $none) #tutorial: tutorial,
      if (error != $none) #error: error,
    }),
  );
  @override
  TutorialResponse $make(CopyWithData data) => TutorialResponse(
    data.get(#tutorial, or: $value.tutorial),
    data.get(#error, or: $value.error),
  );

  @override
  TutorialResponseCopyWith<$R2, TutorialResponse, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  ) => _TutorialResponseCopyWithImpl<$R2, $Out2>($value, $cast, t);
}

class TutorialConfigMapper extends ClassMapperBase<TutorialConfig> {
  TutorialConfigMapper._();

  static TutorialConfigMapper? _instance;
  static TutorialConfigMapper ensureInitialized() {
    if (_instance == null) {
      MapperContainer.globals.use(_instance = TutorialConfigMapper._());
      TutorialStepConfigMapper.ensureInitialized();
      TutorialStepMapper.ensureInitialized();
    }
    return _instance!;
  }

  @override
  final String id = 'TutorialConfig';

  static String _$id(TutorialConfig v) => v.id;
  static const Field<TutorialConfig, String> _f$id = Field('id', _$id);
  static String _$name(TutorialConfig v) => v.name;
  static const Field<TutorialConfig, String> _f$name = Field('name', _$name);
  static List<TutorialStepConfig> _$steps(TutorialConfig v) => v.steps;
  static const Field<TutorialConfig, List<TutorialStepConfig>> _f$steps = Field(
    'steps',
    _$steps,
  );
  static TutorialStep _$initialStep(TutorialConfig v) => v.initialStep;
  static const Field<TutorialConfig, TutorialStep> _f$initialStep = Field(
    'initialStep',
    _$initialStep,
  );

  @override
  final MappableFields<TutorialConfig> fields = const {
    #id: _f$id,
    #name: _f$name,
    #steps: _f$steps,
    #initialStep: _f$initialStep,
  };

  static TutorialConfig _instantiate(DecodingData data) {
    return TutorialConfig(
      data.dec(_f$id),
      data.dec(_f$name),
      data.dec(_f$steps),
      data.dec(_f$initialStep),
    );
  }

  @override
  final Function instantiate = _instantiate;

  static TutorialConfig fromMap(Map<String, dynamic> map) {
    return ensureInitialized().decodeMap<TutorialConfig>(map);
  }

  static TutorialConfig fromJson(String json) {
    return ensureInitialized().decodeJson<TutorialConfig>(json);
  }
}

mixin TutorialConfigMappable {
  String toJson() {
    return TutorialConfigMapper.ensureInitialized().encodeJson<TutorialConfig>(
      this as TutorialConfig,
    );
  }

  Map<String, dynamic> toMap() {
    return TutorialConfigMapper.ensureInitialized().encodeMap<TutorialConfig>(
      this as TutorialConfig,
    );
  }

  TutorialConfigCopyWith<TutorialConfig, TutorialConfig, TutorialConfig>
  get copyWith => _TutorialConfigCopyWithImpl<TutorialConfig, TutorialConfig>(
    this as TutorialConfig,
    $identity,
    $identity,
  );
  @override
  String toString() {
    return TutorialConfigMapper.ensureInitialized().stringifyValue(
      this as TutorialConfig,
    );
  }

  @override
  bool operator ==(Object other) {
    return TutorialConfigMapper.ensureInitialized().equalsValue(
      this as TutorialConfig,
      other,
    );
  }

  @override
  int get hashCode {
    return TutorialConfigMapper.ensureInitialized().hashValue(
      this as TutorialConfig,
    );
  }
}

extension TutorialConfigValueCopy<$R, $Out>
    on ObjectCopyWith<$R, TutorialConfig, $Out> {
  TutorialConfigCopyWith<$R, TutorialConfig, $Out> get $asTutorialConfig =>
      $base.as((v, t, t2) => _TutorialConfigCopyWithImpl<$R, $Out>(v, t, t2));
}

abstract class TutorialConfigCopyWith<$R, $In extends TutorialConfig, $Out>
    implements ClassCopyWith<$R, $In, $Out> {
  ListCopyWith<
    $R,
    TutorialStepConfig,
    TutorialStepConfigCopyWith<$R, TutorialStepConfig, TutorialStepConfig>
  >
  get steps;
  TutorialStepCopyWith<$R, TutorialStep, TutorialStep> get initialStep;
  $R call({
    String? id,
    String? name,
    List<TutorialStepConfig>? steps,
    TutorialStep? initialStep,
  });
  TutorialConfigCopyWith<$R2, $In, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  );
}

class _TutorialConfigCopyWithImpl<$R, $Out>
    extends ClassCopyWithBase<$R, TutorialConfig, $Out>
    implements TutorialConfigCopyWith<$R, TutorialConfig, $Out> {
  _TutorialConfigCopyWithImpl(super.value, super.then, super.then2);

  @override
  late final ClassMapperBase<TutorialConfig> $mapper =
      TutorialConfigMapper.ensureInitialized();
  @override
  ListCopyWith<
    $R,
    TutorialStepConfig,
    TutorialStepConfigCopyWith<$R, TutorialStepConfig, TutorialStepConfig>
  >
  get steps => ListCopyWith(
    $value.steps,
    (v, t) => v.copyWith.$chain(t),
    (v) => call(steps: v),
  );
  @override
  TutorialStepCopyWith<$R, TutorialStep, TutorialStep> get initialStep =>
      $value.initialStep.copyWith.$chain((v) => call(initialStep: v));
  @override
  $R call({
    String? id,
    String? name,
    List<TutorialStepConfig>? steps,
    TutorialStep? initialStep,
  }) => $apply(
    FieldCopyWithData({
      if (id != null) #id: id,
      if (name != null) #name: name,
      if (steps != null) #steps: steps,
      if (initialStep != null) #initialStep: initialStep,
    }),
  );
  @override
  TutorialConfig $make(CopyWithData data) => TutorialConfig(
    data.get(#id, or: $value.id),
    data.get(#name, or: $value.name),
    data.get(#steps, or: $value.steps),
    data.get(#initialStep, or: $value.initialStep),
  );

  @override
  TutorialConfigCopyWith<$R2, TutorialConfig, $Out2> $chain<$R2, $Out2>(
    Then<$Out2, $R2> t,
  ) => _TutorialConfigCopyWithImpl<$R2, $Out2>($value, $cast, t);
}

